home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / p4 / p4-1_2c.lha / p4-1.2c / lib / p4_mon.c < prev    next >
C/C++ Source or Header  |  1993-05-24  |  5KB  |  270 lines
  1. #include "p4.h"
  2. #include "p4_sys.h"
  3.  
  4. int p4_moninit(m, i)
  5. p4_monitor_t *m;
  6. int i;
  7. {
  8.     int j;
  9.     struct p4_mon_queue *q;
  10.  
  11.     p4_lock_init(&(m->mon_lock));
  12.  
  13.     if (i)
  14.     {
  15.     m->qs = (struct p4_mon_queue *) p4_shmalloc(sizeof(struct p4_mon_queue) * i);
  16.     if (m->qs == NULL)
  17.     {
  18.         p4_dprintf("OOPS! p4_moninit: p4_shmalloc failed ***\n");
  19.         return (-1);
  20.     }
  21.     for (j = 0; j < i; j++)
  22.     {
  23.         q = m->qs + j;
  24.         q->count = 0;
  25.         p4_lock_init(&(q->delay_lock));
  26.         p4_lock(&(q->delay_lock));
  27.     }
  28.     }
  29.     else
  30.     m->qs = NULL;
  31.     return (0);
  32. }
  33.  
  34. P4VOID p4_menter(m)
  35. p4_monitor_t *m;
  36. {
  37.     ALOG_LOG(p4_local->my_id,REQUEST_MONITOR_ENTRY,m,"");
  38.     p4_lock(&(m->mon_lock));
  39.     ALOG_LOG(p4_local->my_id,ENTER_MONITOR,m,"");
  40. }
  41.  
  42. P4VOID p4_mexit(m)
  43. p4_monitor_t *m;
  44. {
  45.     ALOG_LOG(p4_local->my_id,OPEN_DOOR,m,"");
  46.     ALOG_LOG(p4_local->my_id,EXIT_MONITOR,m,"");
  47.     p4_unlock(&(m->mon_lock));
  48. }
  49.  
  50. P4VOID p4_mdelay(m, i)
  51. p4_monitor_t *m;
  52. int i;
  53. {
  54.     struct p4_mon_queue *q;
  55.  
  56.     q = m->qs + i;
  57.     q->count++;
  58.     ALOG_LOG(p4_local->my_id,ENTER_DELAY_QUEUE,m,"");
  59.     ALOG_LOG(p4_local->my_id,OPEN_DOOR,m,"");
  60.     p4_unlock(&(m->mon_lock));
  61.     p4_lock(&(q->delay_lock));
  62.     ALOG_LOG(p4_local->my_id,EXIT_DELAY_QUEUE,m,"");
  63. }
  64.  
  65. P4VOID p4_mcontinue(m, i)
  66. p4_monitor_t *m;
  67. int i;
  68. {
  69.     struct p4_mon_queue *q;
  70.  
  71.     q = m->qs + i;
  72.     if (q->count)
  73.     {
  74.     q->count--;
  75.     ALOG_LOG(p4_local->my_id,SECRET_EXIT_MONITOR,m,"");
  76.     p4_unlock(&(q->delay_lock));
  77.     }
  78.     else
  79.     {
  80.     ALOG_LOG(p4_local->my_id,OPEN_DOOR,m,"");
  81.     ALOG_LOG(p4_local->my_id,EXIT_MONITOR,m,"");
  82.     p4_unlock(&(m->mon_lock));
  83.     }
  84. }
  85.  
  86. int num_in_mon_queue(m, i)
  87. int i;
  88. p4_monitor_t *m;
  89. {
  90.     struct p4_mon_queue *q;
  91.  
  92.     q = m->qs + i;
  93.     return (q->count);
  94. }
  95.  
  96.  
  97. /* ------------------  getsub monitor -------------------- */
  98.  
  99. int p4_getsub_init(gs)
  100. p4_getsub_monitor_t *gs;
  101. {
  102.  
  103.     gs->sub = 0;
  104.     return (p4_moninit(&(gs->m), 1));
  105. }
  106.  
  107. P4VOID p4_getsubs(gs, s, max, nprocs, stride)
  108. p4_getsub_monitor_t *gs;
  109. int *s, max, nprocs, stride;
  110. {
  111.     p4_menter(&(gs->m));
  112.     if (gs->sub <= max)
  113.     {
  114.     *s = gs->sub;
  115.     gs->sub += stride;
  116.     p4_mexit(&(gs->m));
  117.     }
  118.     else
  119.     {
  120.     *s = -1;
  121.     if (num_in_mon_queue(&(gs->m), 0) < nprocs - 1)
  122.         p4_mdelay(&(gs->m), 0);
  123.     else
  124.         gs->sub = 0;
  125.     p4_mcontinue(&(gs->m), 0);
  126.     }
  127. }
  128.  
  129.  
  130. /* ------------------  barrier monitor -------------------- */
  131.  
  132. int p4_barrier_init(b)
  133. p4_barrier_monitor_t *b;
  134. {
  135.  
  136.     return (p4_moninit(&(b->m), 1));
  137. }
  138.  
  139. P4VOID p4_barrier(b, nprocs)
  140. p4_barrier_monitor_t *b;
  141. int nprocs;
  142. {
  143.     p4_menter(&(b->m));
  144.     if (num_in_mon_queue(&(b->m), 0) < nprocs - 1)
  145.     p4_mdelay(&(b->m), 0);
  146.     p4_mcontinue(&(b->m), 0);
  147. }
  148.  
  149.  
  150. /* ------------------  askfor monitor -------------------- */
  151.  
  152. int p4_askfor_init(af)
  153. p4_askfor_monitor_t *af;
  154. {
  155.  
  156.     af->pgdone = 0;
  157.     af->pbdone = 0;
  158.     /* alog assumes only one askfor per program */
  159.     ALOG_LOG(p4_local->my_id,PBDONE,0,"");
  160.     ALOG_LOG(p4_local->my_id,PGDONE,0,"");
  161.     ALOG_LOG(p4_local->my_id,UPDATE_NUM_SUBPROBS,0,"");
  162.     return (p4_moninit(&(af->m), 1));
  163. }
  164.  
  165. int p4_askfor(af, nprocs, getprob_fxn, problem, reset_fxn)
  166. p4_askfor_monitor_t *af;
  167. int nprocs;
  168. int (*getprob_fxn) ();
  169. P4VOID *problem;
  170. P4VOID(*reset_fxn) ();
  171. {
  172.     int rc;
  173.  
  174.     p4_menter(&(af->m));
  175.     if (!(af->pgdone) && af->pbdone)
  176.     {
  177.     if (num_in_mon_queue(&(af->m), 0) < nprocs - 1)
  178.     {
  179.         p4_mdelay(&(af->m), 0);
  180.     }
  181.     }
  182.     else
  183.     {
  184.     while (!(af->pgdone) && !(af->pbdone))
  185.     {
  186.         if ((rc = (*getprob_fxn) (problem)) == 0)
  187.         {
  188.         p4_mcontinue(&(af->m), 0);
  189.         return (rc);
  190.         }
  191.         else
  192.         {
  193.         if (num_in_mon_queue(&(af->m), 0) == nprocs - 1)
  194.         {
  195.             af->pbdone = 1;
  196.             ALOG_LOG(p4_local->my_id,PBDONE,1,"");
  197.         }
  198.         else
  199.         {
  200.             p4_mdelay(&(af->m), 0);
  201.         }
  202.         }
  203.     }
  204.     }
  205.     if (af->pgdone)
  206.     {
  207.     rc = (-1);
  208.     p4_mcontinue(&(af->m), 0);
  209.     }
  210.     else
  211.     {
  212.     rc = af->pbdone;
  213.     if (num_in_mon_queue(&(af->m), 0) == 0)
  214.     {
  215.         (*reset_fxn) ();
  216.         af->pbdone = 0;
  217.     }
  218.     p4_mcontinue(&(af->m), 0);
  219.     }
  220.     return (rc);
  221. }
  222.  
  223. P4VOID p4_update(af, putprob_fxn, problem)
  224. p4_askfor_monitor_t *af;
  225. int (*putprob_fxn) ();
  226. P4VOID *problem;
  227. {
  228.     p4_menter(&(af->m));
  229.     if (putprob_fxn(problem))
  230.     p4_mcontinue(&(af->m), 0);
  231.     else
  232.     p4_mexit(&(af->m));
  233. }
  234.  
  235. P4VOID p4_probend(af, code)
  236. p4_askfor_monitor_t *af;
  237. int code;
  238. {
  239.     p4_menter(&(af->m));
  240.     af->pbdone = code;
  241.     ALOG_LOG(p4_local->my_id,PBDONE,code,"");
  242.     p4_mexit(&(af->m));
  243. }
  244.  
  245. P4VOID p4_progend(af)
  246. p4_askfor_monitor_t *af;
  247. {
  248.     p4_menter(&(af->m));
  249.     af->pgdone = 1;
  250.     ALOG_LOG(p4_local->my_id,PGDONE,1,"");
  251.     p4_mcontinue(&(af->m), 0);
  252. }
  253.  
  254. int p4_create(fxn)
  255. int (*fxn) ();
  256. {
  257.     int rc;
  258.  
  259.     p4_dprintfl(20,"creating local slave via fork\n");
  260.     if ((rc = fork_p4()) == 0)
  261.     {
  262.     /* slave process */
  263.     (*fxn) ();
  264.     exit(0);
  265.     }
  266.     /* else master process */
  267.     p4_dprintfl(10,"created local slave via fork\n");
  268.     return (rc);
  269. }
  270.